package MyString;

public class SqString implements IString {
    // 字符数组存放数值
    private char[] strValue;
    // 当前串的长度
    private int curLen;

    // 构造空串
    public SqString() {
        strValue = new char[0];
        curLen = 0;
    }

    // 用字符串常量构造串
    public SqString(String str){
        char[] p = str.toCharArray();
        strValue = p;
        curLen = p.length;
    }

    // 以字符数组构造串
    public SqString(char[] str) {
        strValue = new char[str.length];
        for(int i=0; i<str.length; i++){
            strValue[i]=str[i];
        }
        curLen = str.length;
    }


    // 串变为空串
    public void clear() {
        curLen = 0;
    }

    //判断串是否为空串
    public boolean isEmpty() {
        return curLen==0;
    }

    // 返回串的长度
    public int length() {
        return curLen;
    }

    // 返回位序号为i的字符
    public char charAt(int i) throws Exception {
        if(i > curLen || i < 0){
            throw new StringIndexOutOfBoundsException(i);
        }else {
            return strValue[i];
        }
    }

    // 将串的长度扩充为newCapacity
    public void allocate(int newCapacity) {
        char[] tmp = strValue;
        strValue = new char[newCapacity];
        for(int i=0; i<length(); i++){
            strValue[i] = tmp[i];
        }
    }

    // 返回从 begin 到 end-1 的子串
    public IString subString(int begin, int end) {
        if(0 > begin || curLen < begin || begin >= end || end > curLen){
            throw new StringIndexOutOfBoundsException("参数不合法");
        }
        char[] tmp = new char[end - begin];
        for(int i=begin; i<end; i++){
            tmp[i-begin] = strValue[i];
        }
        return new SqString(tmp);
    }

    // 在第i个字符之前插入 str
    public void insert(int i, IString str) throws Exception {
        if(i<0||i>curLen){
            throw new StringIndexOutOfBoundsException("参数不合法");
        }
        int len = str.length();
        // 新分配的空间
        int newCapacity = len + curLen;
        allocate(newCapacity);
        for(int j=i; j<curLen; j++){
            strValue[j+i] = strValue[j];
        }

        for(int j=i; j<i+len; j++){
            // charAt 返回当前位置的值
            strValue[j] = str.charAt(j-i);
        }
        curLen = newCapacity;
    }

    // 删除位序号从 begin 到 end-1 的字符串
    public void delete(int begin, int end) {
        if(begin<0 || begin>=end || begin>=curLen || end>curLen){
            throw new StringIndexOutOfBoundsException("参数不合法");
        }
        for(int i=begin; i<end; i++){
            // 移动 end-begin 的位置的数值
            strValue[i] = strValue[i+end-begin];
        }
        curLen = curLen - end + begin;
    }

    // 将str 链接到字符串的后面
    public void concat(IString str) throws Exception {
        insert(curLen, str);
    }

    // 比较str 与当前字符串的大小
    public int compareTo(IString str) throws Exception {
        int n = Math.min(curLen, str.length());
        for(int i=0; i<n; i++){
            if(strValue[i] > str.charAt(i)){
                return 1;
            }else if(strValue[i] < str.charAt(i)){
                return -1;
            }
        }
        return 0;
    }

    // 从位序号为begin的字符串开始搜索str相等的字符串
    public int indexOf(IString str, int begin) {
        return 0;
    }


}
